//给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
//如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
//您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
//示例：
//输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
//输出：7 -> 0 -> 8
//原因：342 + 465 = 807

// Definition for singly-linked list.
// #[derive(PartialEq, Eq, Clone, Debug)]
// pub struct ListNode {
//   pub val: i32,
//   pub next: Option<Box<ListNode>>
// }
// 
// impl ListNode {
//   #[inline]
//   fn new(val: i32) -> Self {
//     ListNode {
//       next: None,
//       val
//     }
//   }
// }
//个人代码
impl Solution {
    pub fn add_two_numbers(l1: Option<Box<ListNode>>, l2: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
        //返回链表,初始化、表头
        let mut ret=Some(Box::new(ListNode::new(0)));
        let mut node=ret.as_mut();
        //新的链表替代原链表操作
        let (mut n1,mut n2)=(l1,l2);
        //进位值
        let mut a:i32=0;
        while(n1.is_some()||n2.is_some()){
            let mut sum=a;
            if let Some(v) = n1 {
                sum += v.val;
                n1 = v.next;
            }
            if let Some(v) = n2 {
                sum += v.val;
                n2 = v.next;
            }
            a=sum/10;
            let v=node.unwrap();
            v.next=Some(Box::new(ListNode::new(sum%10)));
            node=v.next.as_mut();
        }
        if(a>0){
            let v=node.unwrap();
            v.next=Some(Box::new(ListNode::new(a)));
        }
        ret.unwrap().next
    }
}

 


//大神代码：
// Definition for singly-linked list.
// #[derive(PartialEq, Eq, Clone, Debug)]
// pub struct ListNode {
//   pub val: i32,
//   pub next: Option<Box<ListNode>>
// }
// 
// impl ListNode {
//   #[inline]
//   fn new(val: i32) -> Self {
//     ListNode {
//       next: None,
//       val
//     }
//   }
// }
impl Solution {
    pub fn add_two_numbers(l1: Option<Box<ListNode>>, l2: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
        
      let push_node = |val :i32, node:&mut ListNode| {
            let mut v = node;
            while(v.next.is_some()) {
                v = v.next.as_mut().unwrap();
            }
            v.next = Some(Box::new(ListNode { next: None, val }))
        };
        
        let mut l1 = l1.as_ref();
        let mut l2 = l2.as_ref();
        let mut ss: Option<Box<ListNode>> = Some(Box::new(ListNode::new(0)));
        let mut cu = 0_i32;

        let mut mut_node: &mut Option<Box<ListNode>> = &mut ss;
        loop {
            if None == l1 && None == l2 {
                if cu>0 {
                    // push_node((cu)%10, ss.as_mut().unwrap());
                    mut_node.as_mut().unwrap().next = Some(Box::new(ListNode { next: None, val:(cu)%10 }));
                }
                break;
            }
          
            let v1 = if l1.is_some() {
                l1.as_ref().unwrap().val
            } else {
                0
            };

            let v2 = if l2.is_some() {
                l2.as_ref().unwrap().val
            } else {
                0
            };
            let sum = v1+v2+cu;
            cu = sum/10;
            let vv = sum%10;
            // if None == ss {
            //     ss = Some(Box::new(ListNode::new(vv)));
            // } else {
                mut_node.as_mut().unwrap().next = Some(Box::new(ListNode { next: None, val:vv }));
                mut_node =  &mut mut_node.as_mut().unwrap().next;
                //push_node(vv, ss.as_mut().unwrap());
            // }
            if l1.is_some() {
                l1 = l1.unwrap().next.as_ref();
            }
            if l2.is_some() {
                l2 = l2.unwrap().next.as_ref();
            }
        }
        let ss = ss;
        ss.unwrap().next
    }
}